public class Main {
	public static void main(String[] args) {
		int[][] ns = {
			{ 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
		};

		System.out.println(ns.length); //3
		//因为ns包含3个数组，因此，ns.length为3。
		System.out.println(Arrays.toString(ns));
		/*
		实际上ns在内存中的结构如下：

		                    ┌───┬───┬───┬───┐
		         ┌───┐  ┌──>│ 1 │ 2 │ 3 │ 4 │
		ns ─────>│░░░│──┘   └───┴───┴───┴───┘
		         ├───┤      ┌───┬───┬───┬───┐
		         │░░░│─────>│ 5 │ 6 │ 7 │ 8 │
		         ├───┤      └───┴───┴───┴───┘
		         │░░░│──┐   ┌───┬───┬───┬───┐
		         └───┘  └──>│ 9 │10 │11 │12 │
		                    └───┴───┴───┴───┘
		*/


		//二维数组
		int[][] ns = {
			{ 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
		};
		int[] arr0 = ns[0];
		System.out.println(arr0.length);
		/*
		实际上arr0就获取了ns数组的第0个元素。因为ns数组的每个元素也是一个数组，因此，arr0指向的数组就是{ 1, 2, 3, 4 }。在内存中，结构如下：

		            arr0 ─────┐
		                      ▼
		                    ┌───┬───┬───┬───┐
		         ┌───┐  ┌──>│ 1 │ 2 │ 3 │ 4 │
		ns ─────>│░░░│──┘   └───┴───┴───┴───┘
		         ├───┤      ┌───┬───┬───┬───┐
		         │░░░│─────>│ 5 │ 6 │ 7 │ 8 │
		         ├───┤      └───┴───┴───┴───┘
		         │░░░│──┐   ┌───┬───┬───┬───┐
		         └───┘  └──>│ 9 │10 │11 │12 │
		*/

		//访问二维数组的某个元素需要使用array[row][col]
		System.out.println(ns[1][2]); //7


		//二维数组的每个数组元素的长度并不要求相同
		//例如，可以这么定义ns数组：
		int[][] ns = {
		    { 1, 2, 3, 4 },
		    { 5, 6 },
		    { 7, 8, 9 }
		};
/*
这个二维数组在内存中的结构如下：

                    ┌───┬───┬───┬───┐
         ┌───┐  ┌──>│ 1 │ 2 │ 3 │ 4 │
ns ─────>│░░░│──┘   └───┴───┴───┴───┘
         ├───┤      ┌───┬───┐
         │░░░│─────>│ 5 │ 6 │
         ├───┤      └───┴───┘
         │░░░│──┐   ┌───┬───┬───┐
         └───┘  └──>│ 7 │ 8 │ 9 │
                    └───┴───┴───┘
*/
        //要打印一个二维数组，可以使用两层嵌套的for循环
        for(int[] arr : ns) {
        	for (int n : arr) {
        		System.out.print(n);
        		System.out.print(',');
        	}
        }

        //或者使用Java标准库Arrays.deepToStrig();
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(Arrays.deepToString(ns));
        //将‘二维数组’每一个数组中的每一个值,都获取
        //Arrays.toString()仅用于1层/表层

        //三维数组
        int[][][] ns = {
            {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
            },
            {
                {10, 11},
                {12, 13}
            },
            {
                {14, 15, 16},
                {17, 18}
            }
        };
        //逗号,分隔
/*
它在内存中的结构如下：

                              ┌───┬───┬───┐
                   ┌───┐  ┌──>│ 1 │ 2 │ 3 │
               ┌──>│░░░│──┘   └───┴───┴───┘
               │   ├───┤      ┌───┬───┬───┐
               │   │░░░│─────>│ 4 │ 5 │ 6 │
               │   ├───┤      └───┴───┴───┘
               │   │░░░│──┐   ┌───┬───┬───┐
        ┌───┐  │   └───┘  └──>│ 7 │ 8 │ 9 │
ns ────>│░░░│──┘              └───┴───┴───┘
        ├───┤      ┌───┐      ┌───┬───┐
        │░░░│─────>│░░░│─────>│10 │11 │
        ├───┤      ├───┤      └───┴───┘
        │░░░│──┐   │░░░│──┐   ┌───┬───┐
        └───┘  │   └───┘  └──>│12 │13 │
               │              └───┴───┘
               │   ┌───┐      ┌───┬───┬───┐
               └──>│░░░│─────>│14 │15 │16 │
                   ├───┤      └───┴───┴───┘
                   │░░░│──┐   ┌───┬───┐
                   └───┘  └──>│17 │18 │
                              └───┴───┘
如果我们要访问三维数组的某个元素，例如，ns[2][0][1]，只需要顺着定位找到对应的最终元素15即可。

理论上，我们可以定义任意的N维数组。但在实际应用中，除了二维数组在某些时候还能用得上，更高维度的数组很少使用。
*/

		

		//练习
		//使用二维数组可以表示一组学生的各科成绩,请计算所有学生的平均分：
		// 用二维数组表示的学生成绩:
        int[][] scores = {
                { 82, 90, 91 },
                { 68, 72, 64 },
                { 95, 91, 89 },
                { 67, 52, 60 },
                { 79, 81, 85 },
        };
        // TODO:

        int i = 0;
        int sum = 0;
        int avg[scores.length];

        for (int m : ns) {
        	for (int n : ns) {
        		sum = sum + n;
        	}
        	avg[i++] = sum / m.length ;
        }


        
        double average = 0;

        for (int n : avg) {
        	average = average + n;
        }
        average = average / avg.length;
        System.out.println(average);

	}
}